const express = require('express');
const router = express.Router();
const { Op } = require('sequelize');
const { createSuccessResponse } = require('../../middleware/responseHandler.js');
const { voteEntryModel, getCreateDefaults, getUpdateDefaults } = require('../../models/voteEntry.js');

// ==================== 投票作品相关接口 ====================
/**
 * 本页面主要方法有：
 * 1.创建投票作品
 * 2.删除投票作品
 * 3.查询投票作品
 * 4.修改投票作品
 * 5.作品统计
 * 6.状态切换
 */

// ==================== 路由定义 ====================

/**
 * 创建投票作品
 * @param {Object} entryData - 作品数据
 * @returns {Promise<object>} 返回创建的作品信息
 * 逻辑:
 * 1.验证作品数据
 * 2.创建作品记录
 * 3.返回作品信息
 */
router.post("/createVoteEntry", (req, res, next) => {
    const {
        vote_id = 0,
        user_id = 0,
        title = '',
        slogan = '',
        author = '',
        image = '',
        video = '',
        file = '',
        content = '',
        is_seed = 0,
        is_verify = 0,
        is_formal = 0,
        seed_number = 0,
        seed_sort = 0
    } = req.body;

    // 参数验证
    if (!title) {
        return res.status(200).json({
            success: false,
            code: 400,
            message: '作品标题不能为空',
            error: '作品标题不能为空',
            timestamp: Date.now()
        });
    }

    if (!vote_id) {
        return res.status(200).json({
            success: false,
            code: 400,
            message: '投票活动ID不能为空',
            error: '投票活动ID不能为空',
            timestamp: Date.now()
        });
    }

    if (!user_id) {
        return res.status(200).json({
            success: false,
            code: 400,
            message: '用户ID不能为空',
            error: '用户ID不能为空',
            timestamp: Date.now()
        });
    }

    // 构建创建数据
    const createData = {
        vote_id: parseInt(vote_id),
        user_id: parseInt(user_id),
        title,
        slogan,
        author,
        image,
        video,
        file,
        content,
        is_seed: parseInt(is_seed),
        is_verify: parseInt(is_verify),
        is_formal: parseInt(is_formal),
        seed_number: parseInt(seed_number),
        seed_sort: parseInt(seed_sort),
        ...getCreateDefaults()
    };

    // 创建作品记录
    voteEntryModel.create(createData)
        .then(newEntry => {
            res.json(createSuccessResponse(newEntry, '作品创建成功'));
        })
        .catch(error => {
            console.error('创建作品错误:', error);
            next(error);
        });
});

/**
 * 删除投票作品（软删除）
 * @param {number|Array} vote_entry_id - 作品ID或作品ID数组
 * @returns {Promise<object>} 返回删除结果
 * 逻辑:
 * 1.验证作品ID
 * 2.检查作品是否存在
 * 3.软删除作品记录
 * 4.返回删除结果
 */
router.post("/deleteVoteEntry", (req, res, next) => {
    const { vote_entry_id } = req.body;

    // 参数验证
    if (!vote_entry_id) {
        return res.status(200).json({
            success: false,
            code: 400,
            message: '作品ID不能为空',
            error: '作品ID不能为空',
            timestamp: Date.now()
        });
    }

    // 判断是单个删除还是批量删除
    const isBatchDelete = Array.isArray(vote_entry_id);

    if (isBatchDelete) {
        // 批量删除逻辑
        if (vote_entry_id.length === 0) {
            return res.status(200).json({
                success: false,
                code: 400,
                message: '作品ID数组不能为空',
                error: '作品ID数组不能为空',
                timestamp: Date.now()
            });
        }

        // 验证所有ID都是有效的
        const validIds = vote_entry_id.filter(id => !isNaN(parseInt(id)));
        if (validIds.length !== vote_entry_id.length) {
            return res.status(200).json({
                success: false,
                code: 400,
                message: '存在无效的作品ID',
                error: '存在无效的作品ID',
                timestamp: Date.now()
            });
        }

        // 批量软删除
        voteEntryModel.update({
            is_delete: 1,
            ...getUpdateDefaults()
        }, {
            where: {
                vote_entry_id: {
                    [Op.in]: validIds
                },
                is_delete: 0
            }
        }).then(result => {
            res.json(createSuccessResponse({
                deleted_count: result[0],
                vote_entry_ids: validIds,
                delete_time: Math.floor(Date.now() / 1000)
            }, `成功删除 ${result[0]} 个作品`));
        }).catch(error => {
            console.error('批量删除作品错误:', error);
            next(error);
        });
    } else {
        // 单个删除逻辑
        if (isNaN(parseInt(vote_entry_id))) {
            return res.status(200).json({
                success: false,
                code: 400,
                message: '作品ID无效',
                error: '作品ID无效',
                timestamp: Date.now()
            });
        }

        // 检查作品是否存在
        voteEntryModel.findOne({
            where: {
                vote_entry_id: parseInt(vote_entry_id),
                is_delete: 0
            }
        }).then(existingEntry => {
            if (!existingEntry) {
                return res.status(200).json({
                    success: false,
                    code: 404,
                    message: '作品不存在',
                    error: '作品不存在',
                    timestamp: Date.now()
                });
            }

            // 软删除作品记录
            return existingEntry.update({
                is_delete: 1,
                ...getUpdateDefaults()
            });
        }).then(deletedEntry => {
            res.json(createSuccessResponse({
                vote_entry_id: deletedEntry.vote_entry_id,
                title: deletedEntry.title,
                delete_time: Math.floor(Date.now() / 1000)
            }, '作品删除成功'));
        }).catch(error => {
            console.error('删除作品错误:', error);
            next(error);
        });
    }
});

/**
 * 查询投票作品列表
 * @param {Object} queryParams - 查询参数
 * @returns {Promise<object>} 返回作品列表
 * 逻辑:
 * 1.解析查询参数
 * 2.根据参数查询作品
 * 3.返回作品信息
 */
router.post("/getVoteEntryList", (req, res, next) => {
    const {
        page = 1,
        pageSize = 10,
        keyword = '',
        vote_id = '',
        user_id = '',
        is_seed = '',
        is_verify = '',
        is_formal = ''
    } = req.body;

    // 构建查询条件
    const where = {
        is_delete: 0
    };

    // 关键词搜索
    if (keyword) {
        where[Op.or] = [
            { title: { [Op.like]: `%${keyword}%` } },
            { slogan: { [Op.like]: `%${keyword}%` } },
            { author: { [Op.like]: `%${keyword}%` } }
        ];
    }

    // 投票活动筛选
    if (vote_id) {
        where.vote_id = parseInt(vote_id);
    }

    // 用户筛选
    if (user_id) {
        where.user_id = parseInt(user_id);
    }

    // 种子状态筛选
    if (is_seed !== '') {
        where.is_seed = parseInt(is_seed);
    }

    // 审核状态筛选
    if (is_verify !== '') {
        where.is_verify = parseInt(is_verify);
    }

    // 禁用状态筛选
    if (is_formal !== '') {
        where.is_formal = parseInt(is_formal);
    }

    // 分页参数
    const offset = (parseInt(page) - 1) * parseInt(pageSize);
    const limit = parseInt(pageSize);

    // 查询作品列表
    voteEntryModel.findAndCountAll({
        where,
        order: [['create_time', 'DESC']],
        limit,
        offset,
        attributes: [
            'vote_entry_id',
            'vote_id',
            'user_id',
            'title',
            'slogan',
            'author',
            'image',
            'video',
            'file',
            'content',
            'is_seed',
            'is_verify',
            'is_formal',
            'seed_number',
            'seed_sort',
            'create_time',
            'update_time'
        ]
    }).then(({ count, rows }) => {
        const totalPages = Math.ceil(count / limit);
        const data = {
            list: rows,
            pagination: {
                page: parseInt(page),
                pageSize: limit,
                total: count,
                totalPages: totalPages,
                hasNext: parseInt(page) < totalPages,
                hasPrev: parseInt(page) > 1
            }
        };

        res.json(createSuccessResponse(data, '查询作品成功'));
    }).catch(error => {
        console.error('查询作品列表错误:', error);
        next(error);
    });
});

/**
 * 根据ID查询投票作品详情
 * @param {number} vote_entry_id - 作品ID
 * @returns {Promise<object>} 返回作品详情
 */
router.post("/getVoteEntryById", (req, res, next) => {
    const { vote_entry_id } = req.body;
    // 参数验证
    if (!vote_entry_id || isNaN(parseInt(vote_entry_id))) {
        return res.status(200).json({
            success: false,
            code: 400,
            message: '作品ID无效',
            error: '作品ID无效',
            timestamp: Date.now()
        });
    }

    // 查询作品详情
    voteEntryModel.findOne({
        where: {
            vote_entry_id: parseInt(vote_entry_id),
            is_delete: 0
        },
        attributes: [
            'vote_entry_id',
            'vote_id',
            'user_id',
            'title',
            'slogan',
            'author',
            'image',
            'video',
            'file',
            'content',
            'is_seed',
            'is_verify',
            'is_formal',
            'seed_number',
            'seed_sort',
            'create_time',
            'update_time'
        ]
    }).then(entryDetail => {
        if (!entryDetail) {
            return res.status(200).json({
                success: false,
                code: 404,
                message: '作品不存在',
                error: '作品不存在',
                timestamp: Date.now()
            });
        }

        res.json(createSuccessResponse(entryDetail, '获取作品详情成功'));
    }).catch(error => {
        console.error('查询作品详情错误:', error);
        next(error);
    });
});

/**
 * 修改投票作品
 * @param {number} vote_entry_id - 作品ID
 * @param {Object} updateData - 更新数据
 * @returns {Promise<object>} 返回更新后的作品信息
 * 逻辑:
 * 1.验证作品ID和更新数据
 * 2.检查作品是否存在
 * 3.更新作品信息
 * 4.返回更新后的作品信息
 */
router.post("/updateVoteEntry", (req, res, next) => {
    const {
        vote_entry_id,
        vote_id,
        user_id,
        title,
        slogan,
        author,
        image,
        video,
        file,
        content,
        is_seed,
        is_verify,
        is_formal,
        seed_number,
        seed_sort
    } = req.body;

    // 参数验证
    if (!vote_entry_id || isNaN(parseInt(vote_entry_id))) {
        return res.status(200).json({
            success: false,
            code: 400,
            message: '作品ID无效',
            error: '作品ID无效',
            timestamp: Date.now()
        });
    }

    // 检查作品是否存在
    voteEntryModel.findOne({
        where: {
            vote_entry_id: parseInt(vote_entry_id),
            is_delete: 0
        }
    }).then(existingEntry => {
        if (!existingEntry) {
            return res.status(200).json({
                success: false,
                code: 404,
                message: '作品不存在',
                error: '作品不存在',
                timestamp: Date.now()
            });
        }

        // 构建更新数据
        const updateData = {
            ...getUpdateDefaults()
        };

        // 只更新提供的字段
        const allowedFields = [
            'vote_id', 'user_id', 'title', 'slogan', 'author',
            'image', 'video', 'file', 'content', 'is_seed',
            'is_verify', 'is_formal', 'seed_number', 'seed_sort'
        ];

        allowedFields.forEach(field => {
            if (req.body[field] !== undefined) {
                // 数值字段需要转换
                if (['vote_id', 'user_id', 'is_seed', 'is_verify', 'is_formal', 'seed_number', 'seed_sort'].includes(field)) {
                    updateData[field] = parseInt(req.body[field]) || 0;
                } else {
                    updateData[field] = req.body[field];
                }
            }
        });

        // 更新作品信息
        return existingEntry.update(updateData);
    }).then(updatedEntry => {
        res.json(createSuccessResponse(updatedEntry, '作品修改成功'));
    }).catch(error => {
        console.error('修改作品错误:', error);
        next(error);
    });
});

/**
 * 获取作品统计信息
 * @param {number} vote_id - 投票活动ID（可选）
 * @param {number} user_id - 用户ID（可选）
 * @returns {Promise<object>} 返回统计信息
 */
router.post("/getVoteEntryStats", (req, res, next) => {
    const { vote_id, user_id } = req.body;

    const where = {
        is_delete: 0
    };

    if (vote_id) {
        where.vote_id = parseInt(vote_id);
    }

    if (user_id) {
        where.user_id = parseInt(user_id);
    }

    // 获取各种统计信息
    Promise.all([
        // 总作品数
        voteEntryModel.count({ where }),
        // 种子作品数
        voteEntryModel.count({ where: { ...where, is_seed: 1 } }),
        // 已审核作品数
        voteEntryModel.count({ where: { ...where, is_verify: 1 } }),
        // 禁用作品数
        voteEntryModel.count({ where: { ...where, is_formal: 1 } }),
        // 未审核作品数
        voteEntryModel.count({ where: { ...where, is_verify: 0 } })
    ]).then(([total, seed, verified, disabled, unverified]) => {
        res.json(createSuccessResponse({
            total,
            seed,
            verified,
            disabled,
            unverified,
            stats_time: Math.floor(Date.now() / 1000)
        }, '获取作品统计成功'));
    }).catch(error => {
        console.error('获取作品统计错误:', error);
        next(error);
    });
});

/**
 * 切换作品状态
 * @param {number} vote_entry_id - 作品ID
 * @param {string} action - 操作类型（verify, unverify, formal, unformal, seed, unseed）
 * @returns {Promise<object>} 返回操作结果
 */
router.post("/toggleVoteEntryStatus", (req, res, next) => {
    const { vote_entry_id, action } = req.body;

    // 参数验证
    if (!vote_entry_id || isNaN(parseInt(vote_entry_id))) {
        return res.status(200).json({
            success: false,
            code: 400,
            message: '作品ID无效',
            error: '作品ID无效',
            timestamp: Date.now()
        });
    }

    if (!['verify', 'unverify', 'formal', 'unformal', 'seed', 'unseed'].includes(action)) {
        return res.status(200).json({
            success: false,
            code: 400,
            message: '操作类型无效',
            error: '操作类型无效',
            timestamp: Date.now()
        });
    }

    // 确定要更新的字段和值
    let updateField, updateValue;
    switch (action) {
        case 'verify':
            updateField = 'is_verify';
            updateValue = 1;
            break;
        case 'unverify':
            updateField = 'is_verify';
            updateValue = 0;
            break;
        case 'formal':
            updateField = 'is_formal';
            updateValue = 1;
            break;
        case 'unformal':
            updateField = 'is_formal';
            updateValue = 0;
            break;
        case 'seed':
            updateField = 'is_seed';
            updateValue = 1;
            break;
        case 'unseed':
            updateField = 'is_seed';
            updateValue = 0;
            break;
    }

    // 更新作品状态
    voteEntryModel.findOne({
        where: {
            vote_entry_id: parseInt(vote_entry_id),
            is_delete: 0
        }
    }).then(existingEntry => {
        if (!existingEntry) {
            return res.status(200).json({
                success: false,
                code: 404,
                message: '作品不存在',
                error: '作品不存在',
                timestamp: Date.now()
            });
        }

        return existingEntry.update({
            [updateField]: updateValue,
            ...getUpdateDefaults()
        });
    }).then(updatedEntry => {
        const actionText = {
            'verify': '审核通过',
            'unverify': '取消审核',
            'formal': '禁用作品',
            'unformal': '启用作品',
            'seed': '设为种子',
            'unseed': '取消种子'
        }[action];

        res.json(createSuccessResponse({
            vote_entry_id: updatedEntry.vote_entry_id,
            title: updatedEntry.title,
            [updateField]: updateValue,
            action: action
        }, `${actionText}成功`));
    }).catch(error => {
        console.error('切换作品状态错误:', error);
        next(error);
    });
});

module.exports = router;